package com.mls.guardian.common;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.tmatesoft.svn.core.*;
import org.tmatesoft.svn.core.auth.ISVNAuthenticationManager;
import org.tmatesoft.svn.core.internal.io.dav.DAVRepositoryFactory;
import org.tmatesoft.svn.core.internal.io.fs.FSRepositoryFactory;
import org.tmatesoft.svn.core.internal.io.svn.SVNRepositoryFactoryImpl;
import org.tmatesoft.svn.core.internal.wc.DefaultSVNOptions;
import org.tmatesoft.svn.core.io.SVNRepository;
import org.tmatesoft.svn.core.io.SVNRepositoryFactory;
import org.tmatesoft.svn.core.wc.*;

import java.io.File;

/**
 * Created by 2014-400 on 2015-10-29.
 */
public class SvnUtilss {
//    private static Logger logger = LoggerFactory.getLogger(SvnUtil.class);
//
//    /**
//     * 通过不同的协议初始化版本库
//     */
//    public static void setupLibrary() {
//        DAVRepositoryFactory.setup();
//        SVNRepositoryFactoryImpl.setup();
//        FSRepositoryFactory.setup();
//    }
//
//    /**
//     * 验证登录svn
//     *
//     * @param svnRoot  项目根目录 http://svn.ambow.com/wlpt/bsp/trunk
//     * @param userName 登陆名
//     * @param password 密码
//     * @return
//     */
//    public static SVNClientManager authSvn(String svnRoot, String userName, String password) {
//        // 初始化版本库
//        setupLibrary();
//
//        // 创建库连接
//        SVNRepository repository = null;
//        try {
//            repository = SVNRepositoryFactory.create(SVNURL.parseURIEncoded(svnRoot));
//        } catch (SVNException e) {
//            logger.error(e.getMessage());
//            return null;
//        }
//
//        // 身份验证
//        ISVNAuthenticationManager authManager = SVNWCUtil.createDefaultAuthenticationManager(userName, password.toCharArray());
//
//        // 创建身份验证管理器
//        repository.setAuthenticationManager(authManager);
//
//        DefaultSVNOptions options = SVNWCUtil.createDefaultOptions(true);
//        SVNClientManager clientManager = SVNClientManager.newInstance(options, authManager);
//
//        return clientManager;
//    }
//
//    /**
//     * Make directory in svn repository
//     *
//     * @param clientManager
//     * @param url           eg: http://svn.ambow.com/wlpt/bsp/trunk
//     * @param commitMessage
//     * @return
//     * @throws SVNException
//     */
//    public static SVNCommitInfo makeDirectory(SVNClientManager clientManager, SVNURL url, String commitMessage) {
//        try {
//            return clientManager.getCommitClient().doMkDir(new SVNURL[]{url}, commitMessage);
//        } catch (SVNException e) {
//            logger.error(e.getMessage());
//        }
//        return null;
//    }
//
//    /**
//     * Imports an unversioned directory into a repository location denoted by a
//     * destination URL
//     *
//     * @param clientManager
//     * @param localPath     a local unversioned directory or singal file that will be imported into a
//     *                      repository;
//     * @param dstURL        a repository location where the local unversioned directory/file will be
//     *                      imported into
//     * @param commitMessage
//     * @param isRecursive   递归
//     * @return
//     */
//    public static SVNCommitInfo importDirectory(SVNClientManager clientManager, File localPath, SVNURL dstURL, String commitMessage, boolean isRecursive) {
//        try {
//            return clientManager.getCommitClient().doImport(localPath, dstURL, commitMessage, null, true, true, SVNDepth.fromRecurse(isRecursive));
//        } catch (SVNException e) {
//            logger.error(e.getMessage());
//        }
//        return null;
//    }
//
//    /**
//     * Puts directories and files under version control
//     *
//     * @param clientManager SVNClientManager
//     * @param wcPath        work copy path
//     */
//    public static void addEntry(SVNClientManager clientManager, File wcPath) {
//        try {
//            clientManager.getWCClient().doAdd(new File[]{wcPath}, true, false, false, SVNDepth.INFINITY, false, false, true);
//        } catch (SVNException e) {
//            logger.error(e.getMessage());
//        }
//    }
//
//    /**
//     * Collects status information on a single Working Copy item
//     *
//     * @param clientManager
//     * @param wcPath        local item's path
//     * @param remote        true to check up the status of the item in the repository,
//     *                      that will tell if the local item is out-of-date (like '-u' option in the SVN client's
//     *                      'svn status' command), otherwise false
//     * @return
//     * @throws SVNException
//     */
//    public static SVNStatus showStatus(SVNClientManager clientManager, File wcPath, boolean remote) {
//        SVNStatus status = null;
//        try {
//            status = clientManager.getStatusClient().doStatus(wcPath, remote);
//        } catch (SVNException e) {
//            logger.error(e.getMessage());
//        }
//        return status;
//    }
//
//    /**
//     * Commit work copy's change to svn
//     *
//     * @param clientManager
//     * @param wcPath        working copy paths which changes are to be committed
//     * @param keepLocks     whether to unlock or not files in the repository
//     * @param commitMessage commit log message
//     * @return
//     * @throws SVNException
//     */
//    public static SVNCommitInfo commit(SVNClientManager clientManager, File wcPath, boolean keepLocks, String commitMessage) {
//        try {
//            return clientManager.getCommitClient().doCommit(new File[]{wcPath}, keepLocks, commitMessage, null, null, false, false, SVNDepth.INFINITY);
//        } catch (SVNException e) {
//            logger.error(e.getMessage());
//        }
//        return null;
//    }
//
//    /**
//     * Updates a working copy (brings changes from the repository into the working copy).
//     *
//     * @param clientManager
//     * @param wcPath           working copy path
//     * @param updateToRevision revision to update to
//     * @param depth            update的深度：目录、子目录、文件
//     * @return
//     * @throws SVNException
//     */
//    public static long update(SVNClientManager clientManager, File wcPath, SVNRevision updateToRevision, SVNDepth depth) {
//        SVNUpdateClient updateClient = clientManager.getUpdateClient();
//
//        /*
//         * sets externals not to be ignored during the update
//         */
//        updateClient.setIgnoreExternals(false);
//
//        /*
//         * returns the number of the revision wcPath was updated to
//         */
//        try {
//            return updateClient.doUpdate(wcPath, updateToRevision, depth, false, false);
//        } catch (SVNException e) {
//            logger.error(e.getMessage());
//        }
//        return 0;
//    }
//
//    /**
//     * 导出文件,不校验版本号,速度更快
//     *
//     * @param clientManager
//     * @param url
//     * @param wcPath
//     * @param depth
//     * @return
//     */
//    public static long export(SVNClientManager clientManager, SVNURL url, File wcPath, SVNDepth depth) {
//        SVNUpdateClient updateClient = clientManager.getUpdateClient();
//
//        /*
//         * sets externals not to be ignored during the update
//         */
//        updateClient.setIgnoreExternals(false);
//
//        /*
//         * returns the number of the revision wcPath was updated to
//         */
//        try {
//            return updateClient.doExport(url, wcPath, SVNRevision.HEAD, SVNRevision.HEAD, "download-end", true, depth);
//        } catch (SVNException e) {
//            logger.error(e.getMessage());
//        }
//        return 0;
//    }
//
//
//    /**
//     * recursively checks out a working copy from url into wcDir
//     *
//     * @param clientManager
//     * @param url           a repository location from where a Working Copy will be checked out
//     * @param revision      the desired revision of the Working Copy to be checked out
//     * @param destPath      the local path where the Working Copy will be placed
//     * @param depth         checkout的深度，目录、子目录、文件
//     * @return
//     * @throws SVNException
//     */
//    public static long checkout(SVNClientManager clientManager, SVNURL url, SVNRevision revision, File destPath, SVNDepth depth) {
//
//        SVNUpdateClient updateClient = clientManager.getUpdateClient();
//        /*
//         * sets externals not to be ignored during the checkout
//         */
//        updateClient.setIgnoreExternals(false);
//        /*
//         * returns the number of the revision at which the working copy is
//         */
//        try {
//            return updateClient.doCheckout(url, destPath, revision, revision, depth, false);
//        } catch (SVNException e) {
//            logger.error(e.getMessage());
//        }
//        return 0;
//    }
//
//    /**
//     * 确定path是否是一个工作空间
//     *
//     * @param path
//     * @return
//     */
//    public static boolean isWorkingCopy(File path) {
//        if (!path.exists()) {
//            logger.warn("'" + path + "' not exist!");
//            return false;
//        }
//        try {
//            if (null == SVNWCUtil.getWorkingCopyRoot(path, false)) {
//                return false;
//            }
//        } catch (SVNException e) {
//            logger.error(e.getMessage());
//        }
//        return true;
//    }
//
//    /**
//     * 确定一个URL在SVN上是否存在
//     *
//     * @param url
//     * @return
//     */
//    public static boolean isURLExist(SVNURL url, String username, String password) {
//        try {
//            SVNRepository svnRepository = SVNRepositoryFactory.create(url);
//            ISVNAuthenticationManager authManager = SVNWCUtil.createDefaultAuthenticationManager(username, password.toCharArray());
//            svnRepository.setAuthenticationManager(authManager);
//            SVNNodeKind nodeKind = svnRepository.checkPath("", -1);
//            return nodeKind == SVNNodeKind.NONE ? false : true;
//        } catch (SVNException e) {
//            e.printStackTrace();
//        }
//        return false;
//    }
//
//    public static long getLastVersion(String url, String userName, String password) {
//        try {
////            SVNRepository svnRepository = SVNRepositoryFactory.create(SVNURL.parseURIEncoded(url));
////            //身份验证
////            ISVNAuthenticationManager authManager = SVNWCUtil.createDefaultAuthenticationManager(userName, password.toCharArray());
////            svnRepository.setAuthenticationManager(authManager);
////            return svnRepository.getLatestRevision();
//            SVNClientManager clientManager = authSvn(url, userName, password);
//            if (clientManager != null) {
//                return clientManager.getRepositoryPool().createRepository(SVNURL.parseURIEncoded(url), true).getLatestRevision();
//            }
//
//        } catch (Exception e) {
//            logger.error(e.getMessage());
//        }
//
//        return 0L;
//    }
//
//    public static void main(String[] args) {
//        System.out.println(SvnUtil.getLastVersion("http://svn.meilishuo.com/repos/wms/Java/BMSPlatform", "yangliurd", "p@s0rd123"));
//
////        try {
////            String url = "http://svn.meilishuo.com/repos/wms/Java/BMSPlatform";
////            if (SvnUtil.isURLExist(SVNURL.parseURIEncoded(url), "yangliurd", "p@s0rd123")) {
////                SVNClientManager manager = SvnUtil.authSvn(url, "yangliurd", "p@s0rd123");
////
////                long rtn = -1;
////                File file = new File("/Users/pengrenfang/Guardian");
////                long start = System.currentTimeMillis();
//////                if (!SVNWCUtil.isVersionedDirectory(file)) {
//////                    rtn = SvnUtil.checkout(manager, SVNURL.parseURIEncoded(url), SVNRevision.HEAD, file, SVNDepth.INFINITY);
//////                } else {
//////                    rtn = SvnUtil.update(manager, file, SVNRevision.HEAD, SVNDepth.INFINITY);
//////                }
////                FileUtil.deleteFolder("/Users/pengrenfang/Guardian");
////
////                rtn = SvnUtil.export(manager, SVNURL.parseURIEncoded(url), file, SVNDepth.INFINITY);
////
////                long end = System.currentTimeMillis();
////                System.out.println("done:" + rtn + ";time:" + (end - start));
////            } else {
////                System.out.println("error");
////            }
////        } catch (SVNException e) {
////            e.printStackTrace();
////        }
//    }
}
